home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gdevcgm.c < prev    next >
C/C++ Source or Header  |  1996-09-17  |  14KB  |  475 lines
  1. /* Copyright (C) 1995, 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gdevcgm.c */
  20. /* CGM (Computer Graphics Metafile) driver */
  21. #include "memory_.h"
  22. #include "gx.h"
  23. #include "gserrors.h"
  24. #include "gxdevice.h"
  25. #include "gsparam.h"
  26. #include "gdevcgml.h"
  27. #include "gdevpccm.h"
  28.  
  29. /**************** Future optimizations:
  30.     Do tile_rectangle with pattern
  31.     Keep track of painted area,
  32.       do masked copy_mono with cell array if possible
  33.  ****************/
  34.  
  35. #define fname_size 80
  36.  
  37. typedef struct gx_device_cgm_s {
  38.     gx_device_common;
  39.     char fname[fname_size + 1];
  40.     FILE *file;
  41.     cgm_state *st;
  42.     bool in_picture;
  43. } gx_device_cgm;
  44. /* GC descriptor */
  45. gs_private_st_suffix_add1_final(st_device_cgm, gx_device_cgm,
  46.   "gx_device_cgm", device_cgm_enum_ptrs, device_cgm_reloc_ptrs,
  47.   gx_device_finalize, st_device, st);
  48.  
  49. /* Device procedures */
  50. private dev_proc_open_device(cgm_open);
  51. private dev_proc_output_page(cgm_output_page);
  52. private dev_proc_close_device(cgm_close);
  53. private dev_proc_fill_rectangle(cgm_fill_rectangle);
  54. #if 0
  55. private dev_proc_tile_rectangle(cgm_tile_rectangle);
  56. #else
  57. #define cgm_tile_rectangle NULL
  58. #endif
  59. private dev_proc_copy_mono(cgm_copy_mono);
  60. private dev_proc_copy_color(cgm_copy_color);
  61. private dev_proc_get_params(cgm_get_params);
  62. private dev_proc_put_params(cgm_put_params);
  63.  
  64. /* In principle, all the drawing operations should be polymorphic, */
  65. /* but it's just as easy just to test the depth, since we're not */
  66. /* very concerned about performance. */
  67. #define cgm_device(dname, depth, max_value, dither, map_rgb_color, map_color_rgb)\
  68. {    std_device_color_stype_body(gx_device_cgm, 0, dname, &st_device_cgm,\
  69.       850, 1100, 100, 100, depth, max_value, dither),\
  70.     {    cgm_open,\
  71.         NULL,            /* get_initial_matrix */\
  72.         NULL,            /* sync_output */\
  73.         cgm_output_page,\
  74.         cgm_close,\
  75.         map_rgb_color,\
  76.         map_color_rgb,\
  77.         cgm_fill_rectangle,\
  78.         cgm_tile_rectangle,\
  79.         cgm_copy_mono,\
  80.         cgm_copy_color,\
  81.         NULL,            /* draw_line */\
  82.         NULL,            /* get_bits */\
  83.         cgm_get_params,\
  84.         cgm_put_params\
  85.     },\
  86.      { 0 },        /* fname */\
  87.     0,        /* file */\
  88.     0,        /* st */\
  89.     0 /*false*/    /* in_picture */\
  90. }
  91.  
  92. gx_device_cgm far_data gs_cgmmono_device =
  93.   cgm_device("cgmmono", 1, 1, 2,
  94.     gx_default_map_rgb_color, gx_default_w_b_map_color_rgb);
  95.  
  96. gx_device_cgm far_data gs_cgm8_device =
  97.   cgm_device("cgm8", 8, 6, 7,
  98.     pc_8bit_map_rgb_color, pc_8bit_map_color_rgb);
  99.  
  100. gx_device_cgm far_data gs_cgm24_device =
  101.   cgm_device("cgm24", 24, 255, 255,
  102.     gx_default_rgb_map_rgb_color, gx_default_rgb_map_color_rgb);
  103.  
  104. /* Define allocator procedures for the CGM library. */
  105. private void *
  106. cgm_gs_alloc(void *private_data, uint size)
  107. {    gx_device_cgm *cdev = private_data;
  108.     gs_memory_t *mem =
  109.       (cdev->memory == 0 ? &gs_memory_default : cdev->memory);
  110.     return gs_alloc_bytes(mem, size, "cgm_gs_alloc");
  111. }
  112. private void
  113. cgm_gs_free(void *private_data, void *obj)
  114. {    gx_device_cgm *cdev = private_data;
  115.     gs_memory_t *mem =
  116.       (cdev->memory == 0 ? &gs_memory_default : cdev->memory);
  117.     gs_free_object(mem, obj, "cgm_gs_free");
  118. }
  119.  
  120. /* ---------------- Utilities ---------------- */
  121.  
  122. /* Convert a CGM result code to our error values. */
  123. private int near
  124. cgm_error_code(cgm_result result)
  125. {    switch ( result )
  126.       {
  127.       default:
  128.       case cgm_result_wrong_state: return gs_error_unknownerror;
  129.       case cgm_result_out_of_range: return gs_error_rangecheck;
  130.       case cgm_result_io_error: return gs_error_ioerror;
  131.       }
  132. }
  133. #define check_result(result)\
  134.   if ( result != cgm_result_ok ) return_error(cgm_error_code(result))
  135.  
  136. /* ---------------- Device control ---------------- */
  137.  
  138. /* Open the device */
  139. private int
  140. cgm_open(gx_device *dev)
  141. {    gx_device_cgm *cdev = (gx_device_cgm *)dev;
  142.     cgm_allocator cal;
  143.     static const int elements[] = { -1, 1 };
  144.     cgm_metafile_elements meta;
  145.     cgm_result result;
  146.  
  147.     cdev->file = fopen(cdev->fname, "wb");
  148.     if ( cdev->file == 0 )
  149.       return_error(gs_error_ioerror);
  150.     cal.private_data = cdev;
  151.     cal.alloc = cgm_gs_alloc;
  152.     cal.free = cgm_gs_free;
  153.     cdev->st = cgm_initialize(cdev->file, &cal);
  154.     if ( cdev->st == 0 )
  155.       return_error(gs_error_VMerror);
  156.     result = cgm_BEGIN_METAFILE(cdev->st, "", 0);
  157.     check_result(result);
  158.     meta.metafile_version = 1;
  159.     meta.vdc_type = cgm_vdc_integer;
  160.     meta.integer_precision = sizeof(cgm_int) * 8;
  161.     meta.index_precision = sizeof(cgm_int) * 8;
  162.     meta.color_precision = 8;
  163.     /* If we use color indices at all, they are only 1 byte. */
  164.     meta.color_index_precision = 8;
  165.     meta.maximum_color_index = (1L << cdev->color_info.depth) - 1;
  166.     meta.metafile_element_list = elements,
  167.       meta.metafile_element_list_count = countof(elements) / 2;
  168.     result = cgm_set_metafile_elements(cdev->st, &meta,
  169.                        cgm_set_METAFILE_VERSION |
  170.                        cgm_set_VDC_TYPE |
  171.                        cgm_set_INTEGER_PRECISION |
  172.                        cgm_set_INDEX_PRECISION |
  173.                        cgm_set_COLOR_PRECISION |
  174.                        cgm_set_COLOR_INDEX_PRECISION |
  175.                        cgm_set_MAXIMUM_COLOR_INDEX |
  176.                        cgm_set_METAFILE_ELEMENT_LIST);
  177.     check_result(result);
  178.     cdev->in_picture = false;
  179.     return 0;
  180. }
  181.  
  182. /* Output a page */
  183. private int
  184. cgm_output_page(gx_device *dev, int num_copies, int flush)
  185. {    gx_device_cgm *cdev = (gx_device_cgm *)dev;
  186.     if ( cdev->in_picture )
  187.     {    cgm_result result = cgm_END_PICTURE(cdev->st);
  188.         check_result(result);
  189.         cdev->in_picture = false;
  190.     }
  191.     return 0;
  192. }
  193.  
  194. /* Close the device */
  195. private int
  196. cgm_close(gx_device *dev)
  197. {    gx_device_cgm *cdev = (gx_device_cgm *)dev;
  198.     int code = cgm_output_page(dev, 1, 0);
  199.     cgm_result result;
  200.  
  201.     if ( code < 0 )
  202.       return code;
  203.     result = cgm_END_METAFILE(cdev->st);
  204.     check_result(result);
  205.     result = cgm_terminate(cdev->st);
  206.     check_result(result);
  207.     cdev->st = 0;
  208.     fclose(cdev->file);
  209.     cdev->file = 0;
  210.     return 0;
  211. }
  212.  
  213. /* Get parameters.  CGM devices add OutputFile to the default set. */
  214. private int
  215. cgm_get_params(gx_device *dev, gs_param_list *plist)
  216. {    gx_device_cgm *cdev = (gx_device_cgm *)dev;
  217.     int code = gx_default_get_params(dev, plist);
  218.     gs_param_string ofns;
  219.  
  220.     if ( code < 0 ) return code;
  221.     ofns.data = (const byte *)cdev->fname,
  222.       ofns.size = strlen(cdev->fname),
  223.       ofns.persistent = false;
  224.     return param_write_string(plist, "OutputFile", &ofns);
  225. }
  226.  
  227. /* Put parameters. */
  228. private int
  229. cgm_put_params(gx_device *dev, gs_param_list *plist)
  230. {    gx_device_cgm *cdev = (gx_device_cgm *)dev;
  231.     int ecode = 0;
  232.     int code;
  233.     const char _ds *param_name;
  234.     gs_param_string ofs;
  235.  
  236.     switch ( code = param_read_string(plist, (param_name = "OutputFile"), &ofs) )
  237.     {
  238.     case 0:
  239.         if ( ofs.size > fname_size )
  240.           ecode = gs_error_limitcheck;
  241.         else
  242.           break;
  243.         goto ofe;
  244.     default:
  245.         ecode = code;
  246. ofe:        param_signal_error(plist, param_name, ecode);
  247.     case 1:
  248.         ofs.data = 0;
  249.         break;
  250.     }
  251.  
  252.     if ( ecode < 0 )
  253.       return ecode;
  254.     code = gx_default_put_params(dev, plist);
  255.     if ( code < 0 )
  256.       return code;
  257.  
  258.     if ( ofs.data != 0 )
  259.       {    /* Close the file if it's open. */
  260.         if ( cdev->file != 0 )
  261.           {    fclose(cdev->file);
  262.             cdev->file = 0;
  263.           }
  264.         memcpy(cdev->fname, ofs.data, ofs.size);
  265.         cdev->fname[ofs.size] = 0;
  266.         cdev->file = fopen(cdev->fname, "wb");
  267.         if ( cdev->file == 0 )
  268.           return_error(gs_error_ioerror);
  269.       }
  270.  
  271.     return 0;
  272. }
  273.  
  274. /* ---------------- Drawing ---------------- */
  275.  
  276. /* Set the corner points for a rectangle.  It appears (although */
  277. /* this is not obvious from the CGM specification) that rectangles */
  278. /* are specified with closed, rather than half-open, intervals. */
  279. #define cgm_set_rect(points, xo, yo, w, h)\
  280.   points[1].integer.x = (points[0].integer.x = xo) + (w) - 1,\
  281.   points[1].integer.y = (points[0].integer.y = yo) + (h) - 1
  282.  
  283. /* Set the points for a cell array. */
  284. #define cgm_set_cell_points(pqr, xo, yo, w, h)\
  285.   pqr[0].integer.x = (xo),\
  286.   pqr[0].integer.y = (yo),\
  287.   pqr[1].integer.x = (xo) + (w),\
  288.   pqr[1].integer.y = (yo) + (h),\
  289.   pqr[2].integer.x = (xo) + (w),\
  290.   pqr[2].integer.y = (yo)
  291.  
  292. /* Begin a picture if necessary. */
  293. #define begin_picture(cdev)\
  294.   if ( !cdev->in_picture ) cgm_begin_picture(cdev)
  295. private int
  296. cgm_begin_picture(gx_device_cgm *cdev)
  297. {    cgm_picture_elements pic;
  298.     cgm_result result;
  299.     cgm_edge_width edge;
  300.  
  301.     result = cgm_BEGIN_PICTURE(cdev->st, "", 0);
  302.     check_result(result);
  303.     pic.scaling_mode = cgm_scaling_abstract;
  304.     pic.color_selection_mode =
  305.       (cdev->color_info.depth <= 8 ?
  306.        cgm_color_selection_indexed :
  307.        cgm_color_selection_direct);
  308.     pic.line_width_specification_mode = cgm_line_marker_absolute;
  309.     pic.edge_width_specification_mode = cgm_line_marker_absolute;
  310.     cgm_set_rect(pic.vdc_extent, 0, 0, cdev->width, cdev->height);
  311.     result = cgm_set_picture_elements(cdev->st, &pic,
  312.                       cgm_set_SCALING_MODE |
  313.                       cgm_set_COLOR_SELECTION_MODE |
  314.                       cgm_set_LINE_WIDTH_SPECIFICATION_MODE |
  315.                       cgm_set_EDGE_WIDTH_SPECIFICATION_MODE |
  316.                       cgm_set_VDC_EXTENT);
  317.     check_result(result);
  318.     result = cgm_BEGIN_PICTURE_BODY(cdev->st);
  319.     check_result(result);
  320.     result = cgm_VDC_INTEGER_PRECISION(cdev->st,
  321.                        (cdev->width <= 0x7fff &&
  322.                         cdev->height <= 0x7fff ?
  323.                         16 : sizeof(cdev->width) * 8));
  324.     check_result(result);
  325.     edge.absolute.integer = 0;
  326.     result = cgm_EDGE_WIDTH(cdev->st, &edge);
  327.     check_result(result);
  328.     if ( cdev->color_info.depth <= 8 )
  329.     {    cgm_color colors[256];
  330.         int i;
  331.         for ( i = 0; i < (1 << cdev->color_info.depth); i++ )
  332.         {    gx_color_value rgb[3];
  333.             (*dev_proc(cdev, map_color_rgb))((gx_device *)cdev,
  334.                         (gx_color_index)i, rgb);
  335.             colors[i].rgb.r =
  336.               rgb[0] >> (gx_color_value_bits - 8);
  337.             colors[i].rgb.g =
  338.               rgb[1] >> (gx_color_value_bits - 8);
  339.             colors[i].rgb.b =
  340.               rgb[2] >> (gx_color_value_bits - 8);
  341.         }
  342.         result = cgm_COLOR_TABLE(cdev->st, 0, colors,
  343.                      1 << cdev->color_info.depth);
  344.         check_result(result);
  345.     }
  346.     cdev->in_picture = true;
  347.     return 0;
  348. }
  349.  
  350. /* Convert a gx_color_index to a CGM color. */
  351. private void
  352. cgm_color_from_color_index(cgm_color *pcc, const gx_device_cgm *cdev,
  353.   gx_color_index color)
  354. {    if ( cdev->color_info.depth <= 8 )
  355.         pcc->index = color;
  356.     else
  357.     {    pcc->rgb.r = color >> 16;
  358.         pcc->rgb.g = (color >> 8) & 255;
  359.         pcc->rgb.b = color & 255;
  360.     }
  361. }
  362.  
  363. /* Fill a rectangle. */
  364. private int
  365. cgm_fill_rectangle(gx_device *dev, int x, int y, int w, int h,
  366.   gx_color_index color)
  367. {    gx_device_cgm *cdev = (gx_device_cgm *)dev;
  368.     cgm_color fill_color;
  369.     cgm_point points[2];
  370.     cgm_result result;
  371.  
  372.     fit_fill(dev, x, y, w, h);
  373.     if ( !cdev->in_picture )
  374.       {    /* Check for erasepage. */
  375.         if ( color == (*dev_proc(dev, map_rgb_color))(dev,
  376.                     gx_max_color_value, gx_max_color_value,
  377.                     gx_max_color_value)
  378.            )
  379.           return 0;
  380.         cgm_begin_picture(cdev);
  381.       }
  382.     cgm_color_from_color_index(&fill_color, cdev, color);
  383.     result = cgm_FILL_COLOR(cdev->st, &fill_color);
  384.     check_result(result);
  385.     result = cgm_INTERIOR_STYLE(cdev->st, cgm_interior_style_solid);
  386.     check_result(result);
  387.     cgm_set_rect(points, x, y, w, h);
  388.     result = cgm_RECTANGLE(cdev->st, &points[0], &points[1]);
  389.     check_result(result);
  390.     return 0;
  391. }
  392.  
  393. #if 0
  394. /* Tile a rectangle.  We should do this with a pattern if possible. */
  395. private int
  396. cgm_tile_rectangle(gx_device *dev, const gx_tile_bitmap *tile,
  397.   int x, int y, int w, int h, gx_color_index zero, gx_color_index one,
  398.   int px, int py)
  399. {
  400. }
  401. #endif
  402.  
  403. /* Copy a monochrome bitmap.  Unfortunately, CGM doesn't provide a */
  404. /* masked fill operation; if one of the colors is transparent, */
  405. /* we have to do the copy by filling lots of tiny little rectangles. */
  406. /* A much better way to implement this would be to remember whether */
  407. /* the destination region is still white; if so, we can use a cell array */
  408. /* (or, even better, a pattern).  However, we still need the slow method */
  409. /* for the case where we don't know the background color or it isn't white. */
  410. private int
  411. cgm_copy_mono(gx_device *dev,
  412.   const byte *base, int sourcex, int raster, gx_bitmap_id id,
  413.   int x, int y, int w, int h, gx_color_index zero, gx_color_index one)
  414. {    gx_device_cgm *cdev = (gx_device_cgm *)dev;
  415.     /* The current implementation is about as inefficient as */
  416.     /* one could possibly imagine! */
  417.     int ix, iy;
  418.     cgm_result result;
  419.  
  420.     fit_copy(dev, base, sourcex, raster, id, x, y, w, h);
  421.     begin_picture(cdev);
  422.     if ( zero == 0 && one == 1 && cdev->color_info.depth == 1 )
  423.       {    cgm_point pqr[3];
  424.         cgm_set_cell_points(pqr, x, y, w, h);
  425.         result = cgm_CELL_ARRAY(cdev->st, pqr, w, h, 1,
  426.                     cgm_cell_mode_packed,
  427.                     base, sourcex, raster);
  428.         check_result(result);
  429.       }
  430.     else
  431.       {    result = cgm_INTERIOR_STYLE(cdev->st, cgm_interior_style_solid);
  432.         check_result(result);
  433.         for ( iy = 0; iy < h; iy++ )
  434.           for ( ix = 0; ix < w; ix++ )
  435.             {    int px = ix + sourcex;
  436.             const byte *pixel = &base[iy * raster + (px >> 3)];
  437.             byte mask = 0x80 >> (px & 7);
  438.             gx_color_index color = (*pixel & mask ? one : zero);
  439.             if ( color != gx_no_color_index )
  440.               {    cgm_color fill_color;
  441.                 cgm_point points[2];
  442.                 cgm_color_from_color_index(&fill_color, cdev, color);
  443.                 cgm_set_rect(points, x, y, 1, 1);
  444.                 result = cgm_RECTANGLE(cdev->st, &points[0], &points[1]);
  445.                 check_result(result);
  446.               }
  447.             }
  448.       }
  449.     return 0;
  450. }
  451.  
  452. /* Copy a color bitmap. */
  453. private int
  454. cgm_copy_color(gx_device *dev,
  455.   const byte *base, int sourcex, int raster, gx_bitmap_id id,
  456.   int x, int y, int w, int h)
  457. {    gx_device_cgm *cdev = (gx_device_cgm *)dev;
  458.     int depth = cdev->color_info.depth;
  459.     uint source_bit = sourcex * depth;
  460.     cgm_point pqr[3];
  461.     cgm_result result;
  462.  
  463.     if ( depth == 1 )
  464.       return cgm_copy_mono(dev, base, sourcex, raster, id,
  465.                    x, y, w, h,
  466.                    (gx_color_index)0, (gx_color_index)1);
  467.     fit_copy(dev, base, sourcex, raster, id, x, y, w, h);
  468.     begin_picture(cdev);
  469.     cgm_set_cell_points(pqr, x, y, w, h);
  470.     result = cgm_CELL_ARRAY(cdev->st, pqr, w, h, 0, cgm_cell_mode_packed,
  471.                 base, source_bit, raster);
  472.     check_result(result);
  473.     return 0;
  474. }
  475.